1. 引言

在上一篇文章中，我們介紹了Stream API的基本概念和用法。今天，我們將深入探討Stream API的高級特性，並通過實際案例來展示其在複雜場景中的應用。

2. Stream API回顧與進階概念

基本概念簡要回顧

Stream API是Java 8引入的一個用於處理數據序列的工具，允許以聲明式方式處理集合，並支持函數式風格。
Stream的操作可分為中間操作（如filter、map）和終端操作（如collect、reduce）。

以下針對昨天，再補充部分內容

終端操作

終端操作會遍歷流並產生一個結果。執行終端操作後，流就被消費掉了。常見的終端操作包括：

1. collect：將流元素收集到一個容器中

   List<String> list = stream.collect(Collectors.toList());
   

2. forEach：對每個元素執行操作

   stream.forEach(System.out::println);
   

3. reduce：將流元素組合起來

   Optional<String> combined = stream.reduce((s1, s2) -> s1 + s2);
   

4. count：計算流中的元素個數

   long count = stream.count();
   

短路操作

短路操作可以在不處理所有元素的情況下返回結果。 常見的短路操作包括：

1. findFirst：返回第一個元素

   Optional<String> first = stream.findFirst();
   

2. findAny：返回任意一個元素

   Optional<String> any = stream.findAny();
   

3. anyMatch：檢查是否至少有一個元素匹配給定的條件

   boolean hasA = stream.anyMatch(s -> s.startsWith("a"));
   

4. allMatch：檢查是否所有元素都匹配給定的條件

   boolean allLong = stream.allMatch(s -> s.length() > 5);
   

5. noneMatch：檢查是否沒有元素匹配給定的條件

   boolean noShort = stream.noneMatch(s -> s.length() < 3);
   

數據過濾和轉換

1. 複雜條件過濾：

   List<Person> adults = people.stream()
       .filter(p -> p.getAge() >= 18 && p.getCountry().equals("Taiwan"))
       .collect(Collectors.toList());
   

2. 數據轉換和扁平化：

   List<List<String>> nestedList = Arrays.asList(
       Arrays.asList("a", "b"),
       Arrays.asList("c", "d")
   );
   List<String> flatList = nestedList.stream()
       .flatMap(Collection::stream)
       .collect(Collectors.toList());
   // Output：[a, b, c, d]
   

數據彙總

Stream API適合進行數據彙總操作：

1. 求和：

   List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
   int sum = numbers.stream()
       .reduce(0, Integer::sum);
   // Output：15
   

2. 查找最大值：

   Optional<Integer> max = numbers.stream()
       .max(Integer::compareTo);
   // 結果：Optional[5]
   

3. 分組統計：

   Map<String, Long> countByCountry = people.stream()
       .collect(Collectors.groupingBy(Person::getCountry, Collectors.counting()));
   

自定義Collector

public class CustomCollectorExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");

        String result = names.stream().collect(Collector.of(
            StringBuilder::new,
            (sb, str) -> {
                if (sb.length() > 0) sb.append(", ");
                sb.append(str);
            },
            StringBuilder::append,
            StringBuilder::toString
        ));

        System.out.println(result); // Output: Alice, Bob, Charlie, David
    }
}

使用Spliterator

Spliterator是Java 8引入的另一個重要概念，是Iterator的可分割版本，為並行處理提供了更好的解法。

public class SpliteratorExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
        Spliterator<String> spliterator = names.spliterator();

        spliterator.forEachRemaining(name -> System.out.println("Processing: " + name));
    }
}

3. Stream API與其他Java特性的結合

Stream與Optional

Optional可以與Stream無縫結合，提供更安全和優雅的空值處理。

public class StreamOptionalExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
        Optional<String> firstLongName = names.stream()
            .filter(name -> name.length() > 5)
            .findFirst();

        firstLongName.ifPresent(System.out::println);
    }
}

Stream與CompletableFuture

CompletableFuture可以與Stream結合使用，實現高效的異步處理。

public class StreamCompletableFutureExample {
    public static void main(String[] args) {
        List<String> urls = Arrays.asList("url1", "url2", "url3");
        List<CompletableFuture<String>> futures = urls.stream()
            .map(url -> CompletableFuture.supplyAsync(() -> fetchUrl(url)))
            .collect(Collectors.toList());

        CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join();

        List<String> results = futures.stream()
            .map(CompletableFuture::join)
            .collect(Collectors.toList());

        System.out.println(results);
    }

    private static String fetchUrl(String url) {
        // 模擬網絡請求
        return "Content of " + url;
    }
}

4. 平行Stream

平行Stream是Java 8引入的一個強大特性，利用多核處理器的優勢，並行處理Stream中的元素，從而提高處理大量數據時的效能。在本章節中，我們將探討什麼是平行Stream，如何創建和使用他，以及使用時需要注意的事項。

如何創建和使用平行Stream

創建平行Stream有兩種主要方式：

1. 從現有的集合創建：

   List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
   Stream<Integer> parallelStream = numbers.parallelStream();
   

2. 將順序Stream轉換為平行Stream：

   Stream<Integer> parallelStream = numbers.stream().parallel();
   

使用平行Stream的方式與普通Stream相同，只是處理過程會自動並行化：

int sum = numbers.parallelStream()
    .filter(n -> n % 2 == 0)
    .mapToInt(Integer::intValue)
    .sum();

平行Stream的優勢

1. 提高效能：對於大量數據的處理，平行Stream可以顯著提高處理速度。

2. 簡化並行編程：無需手動管理執行緒，Java運行時會自動處理並行化。

3. 適應性強：同一段程式碼可以在不同核心數的處理器上自動調整並行度。

使用平行Stream時的注意事項

1. 數據量要足夠大：對於小型集合，平行化的開銷可能會超過其帶來的效能提升。

2. 避免使用有狀態的Lambda表達式：並行處理時，有狀態的操作可能導致不可預期的結果。

3. 注意執行緒安全：如果在平行Stream操作中修改共享狀態，需要確保執行緒安全。

4. 考慮合併成本：某些操作（如排序）在並行執行後需要合併結果，這可能會抵消並行化帶來的效能提升。

5. 測試效能：並不是所有情況下平行Stream都比順序Stream快，需要根據實際情況進行測試。

// 效能測試範例
long start = System.currentTimeMillis();
int sum = numbers.parallelStream().sum();
long end = System.currentTimeMillis();
System.out.println("Parallel execution time: " + (end - start) + "ms");

start = System.currentTimeMillis();
sum = numbers.stream().sum();
end = System.currentTimeMillis();
System.out.println("Sequential execution time: " + (end - start) + "ms");

平行Stream，可以幫助我們充分利用現代多核處理器的優勢，但並不是萬能的解決方案，我們需要謹慎考慮數據特性、操作複雜度以及硬體環境等因素，以確保能夠真正獲得效能提升。

5. Stream的性能優化

Stream操作的惰性求值

Stream的一個重要特性是惰性求值（lazy evaluation），這意味著中間操作不會立即執行，而是等到遇到終端操作時才會觸發，理解這一點對於優化Stream性能至關重要。

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
Stream<String> stream = names.stream()
    .filter(name -> name.startsWith("A"))
    .map(String::toUpperCase);
// 此時還沒有執行任何操作

List<String> result = stream.collect(Collectors.toList());
// 只有在這裡，之前的操作才會真正執行

利用惰性求值的特性，我們可以：

1. 將過濾操作（如filter）放在轉換操作（如map）之前，以減少需要轉換的元素數量。
2. 使用短路操作（如findFirst、anyMatch）來避免處理整個Stream。

避免裝箱和拆箱

在處理基本數據類型時，使用專門的Stream可以避免不必要的裝箱和拆箱操作，從而提高性能。

// 避免使用
Stream<Integer> boxedStream = IntStream.range(1, 1000000).boxed();

// 推薦使用
IntStream primitiveStream = IntStream.range(1, 1000000);

使用適當的終端操作

選擇合適的終端操作可以顯著影響Stream的性能：

1. 當只需要一個元素時，使用findFirst()或findAny()而不是collect()。
2. 使用專門的方法如sum()、average()來替代通用的reduce()操作。

// 較慢
int sum = numbers.stream().reduce(0, Integer::sum);

// 較快
int sum = numbers.stream().mapToInt(Integer::intValue).sum();

合理使用並行Stream

並行Stream不總是能提高性能。在以下情況下，並行Stream可能會帶來更好的性能：

1. 數據量大：對於小數據集，並行化的開銷可能超過其帶來的收益。
2. 操作計算密集：如果每個元素的處理都很耗時，並行化可能會有明顯收益。
3. 數據結構易於分割：如ArrayList比LinkedList更適合並行處理。

在使用並行Stream時也要注意：

1. 避免在並行Stream中使用有狀態的Lambda表達式。
2. 注意執行緒安全問題，特別是在修改共享狀態時。

重用Stream源

如果需要多次處理同一數據集，考慮重用Stream的源，而不是重複創建Stream。

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
Supplier<Stream<String>> streamSupplier = names::stream;

long count = streamSupplier.get().filter(name -> name.length() > 4).count();
List<String> filtered = streamSupplier.get().filter(name -> name.length() > 4).collect(Collectors.toList());

6. Stream API的實踐

何時使用Stream

1. 處理大量數據：Stream API特別適合處理大量數據，尤其是當需要進行複雜的轉換、過濾或彙總操作時。

2. 函數式操作：當您的操作可以用函數式的方式表達時，Stream API可以提供更簡潔的解決方案。

3. 鏈式操作：如果您需要進行一系列的數據處理步驟，Stream的鏈式調用可以提高程式碼的可讀性。

List<String> result = people.stream()
    .filter(p -> p.getAge() > 18)
    .map(Person::getName)
    .sorted()
    .limit(10)
    .collect(Collectors.toList());

Stream的可讀性考量

1. 適度使用方法引用：方法引用可以使程式碼更簡潔，但過度使用可能降低可讀性。

// 適度使用方法引用
List<String> names = people.stream()
    .map(Person::getName)
    .collect(Collectors.toList());

// 有時Lambda表達式更清晰
List<String> upperNames = people.stream()
    .map(person -> person.getName().toUpperCase())
    .collect(Collectors.toList());

2. 合理分行：對於複雜的Stream操作，適當的分行可以提高可讀性。

List<String> result = people.stream()
    .filter(p -> p.getAge() > 18)
    .map(Person::getName)
    .sorted()
    .limit(10)
    .collect(Collectors.toList());

3. 使用描述性的中間變量：對於複雜的Stream操作，使用中間變量可以提高程式碼的可讀性和可維護性。

Stream<Person> adultStream = people.stream().filter(p -> p.getAge() > 18);
Stream<String> nameStream = adultStream.map(Person::getName);
List<String> sortedNames = nameStream.sorted().collect(Collectors.toList());

避免副作用

1. 保持Stream操作的純函數特性：避免在Stream操作中修改外部狀態。

// 不推薦
List<String> names = new ArrayList<>();
people.stream().forEach(p -> names.add(p.getName()));

// 推薦
List<String> names = people.stream()
    .map(Person::getName)
    .collect(Collectors.toList());

2. 使用收集器而不是forEach：盡可能使用收集器來產生結果，而不是使用forEach來累積結果。

// 不推薦
Map<String, Integer> ageByName = new HashMap<>();
people.stream().forEach(p -> ageByName.put(p.getName(), p.getAge()));

// 推薦
Map<String, Integer> ageByName = people.stream()
    .collect(Collectors.toMap(Person::getName, Person::getAge));

3. 注意並行Stream的執行緒安全性：在使用並行Stream時，確保操作是執行緒安全的。

// 執行緒不安全
List<String> names = Collections.synchronizedList(new ArrayList<>());
people.parallelStream().forEach(p -> names.add(p.getName()));

// 執行緒安全
List<String> names = people.parallelStream()
    .map(Person::getName)
    .collect(Collectors.toList());

遵循這些實踐，可以幫助我們更有效地利用Stream API，寫出更加簡潔、高效、易於維護的程式碼。在下一章節中，我們將探討Stream API的一些限制和替代方案，幫助您在不同場景下做出選擇。

7. Stream API的限制和替代方案

雖然Stream API為Java程式設計帶來許多便利，但他並非萬能的解決方案。在某些情況下，Stream API可能會遇到限制，或者其他方法可能更為合適。本章節將探討Stream API的一些局限性，以及何時應該考慮使用替代方案。

Stream API的局限性

1. 性能開銷：對於小型集合或簡單操作，Stream API可能引入不必要的性能開銷。

2. 調試困難：由於Stream操作的鏈式調用和惰性求值特性，調試Stream相關的程式碼可能會比較困難。

3. 有限的重用性：Stream只能被消費一次，這可能導致程式碼重複或效率降低。

4. 不支持受檢異常：Stream操作中不能拋出受檢異常，這可能導致錯誤處理變得複雜。

何時不應使用Stream

1. 簡單的迭代：對於簡單的迭代操作，傳統的for循環可能更直觀且效率更高。

// 使用Stream
List<String> names = people.stream()
    .map(Person::getName)
    .collect(Collectors.toList());

// 使用傳統for循環
List<String> names = new ArrayList<>();
for (Person person : people) {
    names.add(person.getName());
}

2. 需要break或continue的場景：Stream API不支持break或continue操作，在這些場景下傳統循環更合適。

3. 需要修改外部變量：雖然技術上可行，但在Stream操作中修改外部變量違背函數式編程的原則，也可能導致並發問題。

4. 處理基本類型數組：雖然Stream API提供專門的IntStream、LongStream等，但在某些情況下，直接操作數組可能更高效。

替代方案

1. 傳統for循環：對於簡單的迭代和需要精確控制的場景，傳統for循環仍然是一個很好的選擇。

for (int i = 0; i < array.length; i++) {
    if (someCondition) {
        // 可以使用break或continue
        break;
    }
    // 可以自由修改外部變量
}

2. Enhanced for循環：對於簡單的集合遍歷，enhanced for循環（for-each循環）通常更簡潔。

for (Person person : people) {
    System.out.println(person.getName());
}

3. Iterator：當需要在迭代過程中移除元素時，使用Iterator可能更合適。

Iterator<Person> iterator = people.iterator();
while (iterator.hasNext()) {
    Person person = iterator.next();
    if (person.getAge() < 18) {
        iterator.remove();
    }
}

4. 第三方庫：一些第三方庫如Google Guava提供額外的集合處理工具，可能在某些場景下更適用。

// 使用Guava的Iterables類
Iterable<String> names = Iterables.transform(people, Person::getName);

8. 實際案例分析

案例描述

假設我們有一個電子商務平台，需要處理大量的訂單數據。我們的任務是找出最近30天內，金額超過1000元的訂單，按照金額降序排列，並返回前10個訂單的客戶名稱。

使用傳統方法

首先，讓我們看看使用傳統方法如何實現這個需求：

public List<String> getTop10CustomerNames(List<Order> orders) {
    List<Order> filteredOrders = new ArrayList<>();
    Date thirtyDaysAgo = Date.from(Instant.now().minus(30, ChronoUnit.DAYS));
    
    // 過濾訂單
    for (Order order : orders) {
        if (order.getDate().after(thirtyDaysAgo) && order.getAmount() > 1000) {
            filteredOrders.add(order);
        }
    }
    
    // 排序訂單
    Collections.sort(filteredOrders, (o1, o2) -> Double.compare(o2.getAmount(), o1.getAmount()));
    
    // 獲取前10個客戶名稱
    List<String> customerNames = new ArrayList<>();
    for (int i = 0; i < Math.min(10, filteredOrders.size()); i++) {
        customerNames.add(filteredOrders.get(i).getCustomerName());
    }
    
    return customerNames;
}

使用Stream API

現在，讓我們看看如何使用Stream API來實現相同的功能：

public List<String> getTop10CustomerNamesWithStream(List<Order> orders) {
    Date thirtyDaysAgo = Date.from(Instant.now().minus(30, ChronoUnit.DAYS));
    
    return orders.stream()
        .filter(order -> order.getDate().after(thirtyDaysAgo) && order.getAmount() > 1000)
        .sorted(Comparator.comparingDouble(Order::getAmount).reversed())
        .limit(10)
        .map(Order::getCustomerName)
        .collect(Collectors.toList());
}

複雜數據處理

假設我們需要對訂單系統進行更複雜的數據分析，例如按類別統計訂單金額：

public class OrderAnalysis {
    public static void main(String[] args) {
        List<Order> orders = Arrays.asList(
            new Order("A001", 100.0, "Electronics"),
            new Order("A002", 200.0, "Books"),
            new Order("A003", 300.0, "Electronics"),
            new Order("A004", 150.0, "Clothing")
        );

        Map<String, DoubleSummaryStatistics> statisticsByCategory = orders.stream()
            .collect(Collectors.groupingBy(
                Order::getCategory,
                Collectors.summarizingDouble(Order::getAmount)
            ));

        statisticsByCategory.forEach((category, stats) -> {
            System.out.println(category + " - Average: " + stats.getAverage() +
                               ", Max: " + stats.getMax() +
                               ", Min: " + stats.getMin());
        });
    }
}

class Order {
    private String id;
    private double amount;
    private String category;

    // Constructor, getters and setters
}

比較分析

1. 程式碼簡潔性：

   • 傳統方法需要約20行程式碼。
   • Stream API方法只需要約7行程式碼。
     Stream API版本明顯更加簡潔，可讀性更高。

2. 可維護性：

   • 傳統方法將過濾、排序和轉換分散在不同的程式碼塊中。
   • Stream API方法將所有操作整合在一個流水線中，邏輯更加清晰。
     Stream API版本的邏輯流程更加清晰，更容易理解和維護。

3. 性能：

   • 對於大量數據，Stream API版本可能會有更好的性能，特別是在多核處理器上使用並行流時。
   • 對於小量數據，傳統方法可能會略微快一些，因為沒有Stream的額外開銷。

4. 靈活性：

   • Stream API版本更容易擴展和修改。例如，如果我們想要改變過濾條件或增加新的轉換步驟，只需要在流水線中添加或修改相應的操作即可。

5. 錯誤處理：

   • 傳統方法可能更容易進行細粒度的錯誤處理。
   • Stream API方法雖然簡潔，但在錯誤處理方面可能不如傳統方法靈活。

本篇文章同步刊載: JYI.TW
筆者個人的網站: JUNYI